﻿using Resn.WhuPub.BLL;
using Microsoft.VisualStudio.TestTools.UnitTesting;
using System;
using Resn.WhuPub.DML;
using Resn.WhuPub.BIL;
using System.Collections.Generic;

namespace Resn.WhuPub.UnitTest
{
    
    
    /// <summary>
    ///这是 EmployeeTest 的测试类，旨在
    ///包含所有 EmployeeTest 单元测试
    ///</summary>
        [TestClass()]
        public class EmployeeTest
        {


                private TestContext testContextInstance;

                /// <summary>
                ///获取或设置测试上下文，上下文提供
                ///有关当前测试运行及其功能的信息。
                ///</summary>
                public TestContext TestContext
                {
                        get
                        {
                                return testContextInstance;
                        }
                        set
                        {
                                testContextInstance = value;
                        }
                }

                #region 附加测试特性
                // 
                //编写测试时，还可使用以下特性:
                //
                //使用 ClassInitialize 在运行类中的第一个测试前先运行代码
                //[ClassInitialize()]
                //public static void MyClassInitialize(TestContext testContext)
                //{
                //}
                //
                //使用 ClassCleanup 在运行完类中的所有测试后再运行代码
                //[ClassCleanup()]
                //public static void MyClassCleanup()
                //{
                //}
                //
                //使用 TestInitialize 在运行每个测试前先运行代码
                //[TestInitialize()]
                //public void MyTestInitialize()
                //{
                //}
                //
                //使用 TestCleanup 在运行完每个测试后运行代码
                //[TestCleanup()]
                //public void MyTestCleanup()
                //{
                //}
                //
                #endregion


                /// <summary>
                ///Employee 构造函数 的测试
                ///</summary>
                [TestMethod()]
                public void EmployeeConstructorTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model);
                        Assert.Inconclusive("TODO: 实现用来验证目标的代码");
                }

                /// <summary>
                ///ContainsProviceAccess 的测试
                ///</summary>
                [TestMethod()]
                public void ContainsProviceAccessTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string access = string.Empty; // TODO: 初始化为适当的值
                        bool expected = false; // TODO: 初始化为适当的值
                        bool actual;
                        actual = target.ContainsProviceAccess(access);
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///CreateTravel 的测试
                ///</summary>
                [TestMethod()]
                public void CreateTravelTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string planContent = string.Empty; // TODO: 初始化为适当的值
                        double lendAmount = 0F; // TODO: 初始化为适当的值
                        DateTime startTime = new DateTime(); // TODO: 初始化为适当的值
                        DateTime endTime = new DateTime(); // TODO: 初始化为适当的值
                        string memo = string.Empty; // TODO: 初始化为适当的值
                        ITravel expected = null; // TODO: 初始化为适当的值
                        ITravel actual;
                        actual = target.CreateTravel(planContent, lendAmount, startTime, endTime, memo);
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Select 的测试
                ///</summary>
                [TestMethod()]
                public void SelectTest()
                {
                        string id = string.Empty; // TODO: 初始化为适当的值
                        Employee expected = null; // TODO: 初始化为适当的值
                        Employee actual;
                        actual = Employee.Select(id);
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Email 的测试
                ///</summary>
                [TestMethod()]
                public void EmailTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Email = expected;
                        actual = target.Email;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///EmployeeLevel 的测试
                ///</summary>
                [TestMethod()]
                public void EmployeeLevelTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        EmployeeLevel expected = new EmployeeLevel(); // TODO: 初始化为适当的值
                        EmployeeLevel actual;
                        target.EmployeeLevel = expected;
                        actual = target.EmployeeLevel;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///EmployeeState 的测试
                ///</summary>
                [TestMethod()]
                public void EmployeeStateTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        EmployeeState expected = new EmployeeState(); // TODO: 初始化为适当的值
                        EmployeeState actual;
                        target.EmployeeState = expected;
                        actual = target.EmployeeState;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Memo 的测试
                ///</summary>
                [TestMethod()]
                public void MemoTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Memo = expected;
                        actual = target.Memo;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Model 的测试
                ///</summary>
                [TestMethod()]
                [DeploymentItem("Resn.WhuPub.BLL.dll")]
                public void ModelTest()
                {
                        PrivateObject param0 = null; // TODO: 初始化为适当的值
                        Employee_Accessor target = new Employee_Accessor(param0); // TODO: 初始化为适当的值
                        EmployeeModel expected = null; // TODO: 初始化为适当的值
                        EmployeeModel actual;
                        target.Model = expected;
                        actual = target.Model;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Name 的测试
                ///</summary>
                [TestMethod()]
                public void NameTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Name = expected;
                        actual = target.Name;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Password 的测试
                ///</summary>
                [TestMethod()]
                public void PasswordTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Password = expected;
                        actual = target.Password;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ProviceAccessCollection 的测试
                ///</summary>
                [TestMethod()]
                public void ProviceAccessCollectionTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        List<string> actual;
                        actual = target.ProviceAccessCollection;
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///ProviceAccesses 的测试
                ///</summary>
                [TestMethod()]
                public void ProviceAccessesTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.ProviceAccesses = expected;
                        actual = target.ProviceAccesses;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///QQ 的测试
                ///</summary>
                [TestMethod()]
                public void QQTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.QQ = expected;
                        actual = target.QQ;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }

                /// <summary>
                ///Telephone 的测试
                ///</summary>
                [TestMethod()]
                public void TelephoneTest()
                {
                        EmployeeModel model = null; // TODO: 初始化为适当的值
                        Employee target = new Employee(model); // TODO: 初始化为适当的值
                        string expected = string.Empty; // TODO: 初始化为适当的值
                        string actual;
                        target.Telephone = expected;
                        actual = target.Telephone;
                        Assert.AreEqual(expected, actual);
                        Assert.Inconclusive("验证此测试方法的正确性。");
                }
        }
}
